home *** CD-ROM | disk | FTP | other *** search
/ Champak 49 / Volume 49 - JOGO DISK .iso / Games / gasmania.swf / scripts / DefineSprite_283_num / frame_16 / DoAction.as
Encoding:
Text File  |  2007-10-01  |  62.7 KB  |  1,224 lines

  1. var ┬º\x01┬º = 825;
  2. loop0:
  3. while(true)
  4. {
  5.    if(eval("\x01") == 825)
  6.    {
  7.       set("\x01",eval("\x01") - 96);
  8.       ┬º┬ºpush(true);
  9.       continue;
  10.    }
  11.    if(eval("\x01") == 712)
  12.    {
  13.       set("\x01",eval("\x01") - 479);
  14.       continue;
  15.    }
  16.    if(eval("\x01") == 125)
  17.    {
  18.       set("\x01",eval("\x01") + 153);
  19.    }
  20.    else
  21.    {
  22.       if(eval("\x01") == 633)
  23.       {
  24.          set("\x01",eval("\x01") + 216);
  25.          ┬º┬ºpush(true);
  26.          continue;
  27.       }
  28.       if(eval("\x01") == 831)
  29.       {
  30.          set("\x01",eval("\x01") - 229);
  31.          continue;
  32.       }
  33.       if(eval("\x01") == 674)
  34.       {
  35.          set("\x01",eval("\x01") + 14);
  36.       }
  37.       else
  38.       {
  39.          if(eval("\x01") == 72)
  40.          {
  41.             set("\x01",eval("\x01") + 201);
  42.             continue;
  43.          }
  44.          if(eval("\x01") == 615)
  45.          {
  46.             set("\x01",eval("\x01") - 404);
  47.             loop11:
  48.             while(true)
  49.             {
  50.                addr34:
  51.                addr377:
  52.                addr378:
  53.                while(true)
  54.                {
  55.                   if(eval("\x01") == 229)
  56.                   {
  57.                      set("\x01",eval("\x01") + 124);
  58.                      ┬º┬ºpush(true);
  59.                      continue;
  60.                   }
  61.                   if(eval("\x01") == 223)
  62.                   {
  63.                      set("\x01",eval("\x01") + 157);
  64.                   }
  65.                   else
  66.                   {
  67.                      if(eval("\x01") == 94)
  68.                      {
  69.                         set("\x01",eval("\x01") + 320);
  70.                         if(┬º┬ºpop())
  71.                         {
  72.                            set("\x01",eval("\x01") + 460);
  73.                         }
  74.                         continue;
  75.                      }
  76.                      if(eval("\x01") == 728)
  77.                      {
  78.                         set("\x01",eval("\x01") - 569);
  79.                         ┬º┬ºpush(true);
  80.                         continue;
  81.                      }
  82.                      if(eval("\x01") == 854)
  83.                      {
  84.                         set("\x01",eval("\x01") - 120);
  85.                         onEnterFrame = function()
  86.                         {
  87.                            if(!_root.Pause)
  88.                            {
  89.                               this.play();
  90.                            }
  91.                            else
  92.                            {
  93.                               this.stop();
  94.                            }
  95.                         };
  96.                      }
  97.                      else if(eval("\x01") == 414)
  98.                      {
  99.                         set("\x01",eval("\x01") + 460);
  100.                         loop3:
  101.                         while(true)
  102.                         {
  103.                            set(┬º┬ºpop(),┬º┬ºpop());
  104.                            loop4:
  105.                            while(true)
  106.                            {
  107.                               while(true)
  108.                               {
  109.                                  if(eval("\x01") == 979)
  110.                                  {
  111.                                     set("\x01",eval("\x01") - 288);
  112.                                     ┬º┬ºpush(true);
  113.                                     continue;
  114.                                  }
  115.                                  if(eval("\x01") == 484)
  116.                                  {
  117.                                     set("\x01",eval("\x01") - 170);
  118.                                     continue;
  119.                                  }
  120.                                  if(eval("\x01") == 324)
  121.                                  {
  122.                                     set("\x01",eval("\x01") + 271);
  123.                                     if(┬º┬ºpop())
  124.                                     {
  125.                                        set("\x01",eval("\x01") + 71);
  126.                                     }
  127.                                     continue;
  128.                                  }
  129.                                  if(eval("\x01") == 314)
  130.                                  {
  131.                                     set("\x01",eval("\x01") + 172);
  132.                                     this.num = null;
  133.                                  }
  134.                                  else if(eval("\x01") == 913)
  135.                                  {
  136.                                     set("\x01",eval("\x01") - 447);
  137.                                  }
  138.                                  else
  139.                                  {
  140.                                     if(eval("\x01") == 464)
  141.                                     {
  142.                                        break loop4;
  143.                                     }
  144.                                     if(eval("\x01") == 486)
  145.                                     {
  146.                                        set("\x01",eval("\x01") - 486);
  147.                                     }
  148.                                     else
  149.                                     {
  150.                                        if(eval("\x01") == 27)
  151.                                        {
  152.                                           set("\x01",eval("\x01") + 917);
  153.                                           ┬º┬ºpush(true);
  154.                                           continue;
  155.                                        }
  156.                                        if(eval("\x01") == 466)
  157.                                        {
  158.                                           set("\x01",eval("\x01") + 472);
  159.                                           continue;
  160.                                        }
  161.                                        if(eval("\x01") == 823)
  162.                                        {
  163.                                           set("\x01",eval("\x01") - 499);
  164.                                           ┬º┬ºpush(true);
  165.                                           continue;
  166.                                        }
  167.                                        if(eval("\x01") == 271)
  168.                                        {
  169.                                           set("\x01",eval("\x01") + 103);
  170.                                        }
  171.                                        else
  172.                                        {
  173.                                           if(eval("\x01") == 666)
  174.                                           {
  175.                                              set("\x01",eval("\x01") - 416);
  176.                                              continue;
  177.                                           }
  178.                                           if(eval("\x01") == 221)
  179.                                           {
  180.                                              set("\x01",eval("\x01") + 126);
  181.                                              if(┬º┬ºpop())
  182.                                              {
  183.                                                 set("\x01",eval("\x01") - 51);
  184.                                              }
  185.                                              continue;
  186.                                           }
  187.                                           if(eval("\x01") == 944)
  188.                                           {
  189.                                              set("\x01",eval("\x01") - 673);
  190.                                              if(┬º┬ºpop())
  191.                                              {
  192.                                                 set("\x01",eval("\x01") + 103);
  193.                                              }
  194.                                              continue;
  195.                                           }
  196.                                           if(eval("\x01") == 538)
  197.                                           {
  198.                                              set("\x01",eval("\x01") - 429);
  199.                                              continue;
  200.                                           }
  201.                                           if(eval("\x01") == 250)
  202.                                           {
  203.                                              set("\x01",eval("\x01") - 29);
  204.                                              ┬º┬ºpush(true);
  205.                                              continue;
  206.                                           }
  207.                                           if(eval("\x01") == 374)
  208.                                           {
  209.                                              set("\x01",eval("\x01") - 228);
  210.                                              continue;
  211.                                           }
  212.                                           if(eval("\x01") == 696)
  213.                                           {
  214.                                              set("\x01",eval("\x01") + 71);
  215.                                              continue;
  216.                                           }
  217.                                           if(eval("\x01") == 933)
  218.                                           {
  219.                                              set("\x01",eval("\x01") - 619);
  220.                                              continue;
  221.                                           }
  222.                                           if(eval("\x01") == 767)
  223.                                           {
  224.                                              set("\x01",eval("\x01") - 481);
  225.                                              ┬º┬ºpush(true);
  226.                                              continue;
  227.                                           }
  228.                                           if(eval("\x01") == 143)
  229.                                           {
  230.                                              set("\x01",eval("\x01") + 3);
  231.                                              continue;
  232.                                           }
  233.                                           if(eval("\x01") == 645)
  234.                                           {
  235.                                              set("\x01",eval("\x01") - 536);
  236.                                              continue;
  237.                                           }
  238.                                           if(eval("\x01") == 347)
  239.                                           {
  240.                                              set("\x01",eval("\x01") - 51);
  241.                                              loop6:
  242.                                              while(true)
  243.                                              {
  244.                                                 if(┬º┬ºpop())
  245.                                                 {
  246.                                                    set("\x01",eval("\x01") - 443);
  247.                                                    if(┬º┬ºpop())
  248.                                                    {
  249.                                                       set("\x01",eval("\x01") - 175);
  250.                                                    }
  251.                                                    while(true)
  252.                                                    {
  253.                                                       if(eval("\x01") == 166)
  254.                                                       {
  255.                                                          set("\x01",eval("\x01") + 775);
  256.                                                          ┬º┬ºpush(true);
  257.                                                          continue;
  258.                                                       }
  259.                                                       if(eval("\x01") == 498)
  260.                                                       {
  261.                                                          break;
  262.                                                       }
  263.                                                       if(eval("\x01") == 311)
  264.                                                       {
  265.                                                          set("\x01",eval("\x01") - 158);
  266.                                                          if(┬º┬ºpop())
  267.                                                          {
  268.                                                             set("\x01",eval("\x01") + 405);
  269.                                                          }
  270.                                                          continue;
  271.                                                       }
  272.                                                       if(eval("\x01") == 389)
  273.                                                       {
  274.                                                          set("\x01",eval("\x01") + 559);
  275.                                                          continue;
  276.                                                       }
  277.                                                       if(eval("\x01") == 277)
  278.                                                       {
  279.                                                          set("\x01",eval("\x01") + 671);
  280.                                                          continue;
  281.                                                       }
  282.                                                       if(eval("\x01") == 948)
  283.                                                       {
  284.                                                          set("\x01",eval("\x01") - 637);
  285.                                                          ┬º┬ºpush(true);
  286.                                                          continue;
  287.                                                       }
  288.                                                       continue loop6;
  289.                                                    }
  290.                                                    set("\x01",eval("\x01") - 175);
  291.                                                    stop();
  292.                                                    addr1317:
  293.                                                    loop10:
  294.                                                    while(true)
  295.                                                    {
  296.                                                       set(┬º┬ºpop(),┬º┬ºpop() + ┬º┬ºpop());
  297.                                                       loop9:
  298.                                                       while(true)
  299.                                                       {
  300.                                                          if(eval("\x01") == 217)
  301.                                                          {
  302.                                                             set("\x01",eval("\x01") + 572);
  303.                                                             ┬º┬ºpush(true);
  304.                                                             continue;
  305.                                                          }
  306.                                                          if(eval("\x01") == 245)
  307.                                                          {
  308.                                                             set("\x01",eval("\x01") + 2);
  309.                                                             continue;
  310.                                                          }
  311.                                                          if(eval("\x01") == 798)
  312.                                                          {
  313.                                                             set("\x01",eval("\x01") - 584);
  314.                                                             ┬º┬ºpush(true);
  315.                                                             continue;
  316.                                                          }
  317.                                                          if(eval("\x01") == 124)
  318.                                                          {
  319.                                                             set("\x01",eval("\x01") - 77);
  320.                                                             if(┬º┬ºpop())
  321.                                                             {
  322.                                                                set("\x01",eval("\x01") + 123);
  323.                                                             }
  324.                                                             continue;
  325.                                                          }
  326.                                                          if(eval("\x01") == 358)
  327.                                                          {
  328.                                                             ┬º┬ºpush("\x01");
  329.                                                             ┬º┬ºpush(eval("\x01"));
  330.                                                             ┬º┬ºpush(440);
  331.                                                             continue loop10;
  332.                                                          }
  333.                                                          if(eval("\x01") == 934)
  334.                                                          {
  335.                                                             set("\x01",eval("\x01") - 143);
  336.                                                             ┬º┬ºpush(true);
  337.                                                             continue;
  338.                                                          }
  339.                                                          if(eval("\x01") == 214)
  340.                                                          {
  341.                                                             set("\x01",eval("\x01") - 175);
  342.                                                             if(┬º┬ºpop())
  343.                                                             {
  344.                                                                set("\x01",eval("\x01") + 361);
  345.                                                             }
  346.                                                             continue;
  347.                                                          }
  348.                                                          if(eval("\x01") == 755)
  349.                                                          {
  350.                                                             set("\x01",eval("\x01") - 631);
  351.                                                             ┬º┬ºpush(true);
  352.                                                             continue;
  353.                                                          }
  354.                                                          if(eval("\x01") == 247)
  355.                                                          {
  356.                                                             set("\x01",eval("\x01") - 10);
  357.                                                             ┬º┬ºpush(true);
  358.                                                             continue;
  359.                                                          }
  360.                                                          if(eval("\x01") == 400)
  361.                                                          {
  362.                                                             set("\x01",eval("\x01") - 153);
  363.                                                             continue;
  364.                                                          }
  365.                                                          if(eval("\x01") == 745)
  366.                                                          {
  367.                                                             set("\x01",eval("\x01") + 189);
  368.                                                             continue;
  369.                                                          }
  370.                                                          if(eval("\x01") == 73)
  371.                                                          {
  372.                                                             break;
  373.                                                          }
  374.                                                          if(eval("\x01") == 234)
  375.                                                          {
  376.                                                             set("\x01",eval("\x01") + 293);
  377.                                                             continue;
  378.                                                          }
  379.                                                          if(eval("\x01") == 466)
  380.                                                          {
  381.                                                             set("\x01",eval("\x01") + 289);
  382.                                                             continue;
  383.                                                          }
  384.                                                          addr2365:
  385.                                                          addr1017:
  386.                                                          addr1012:
  387.                                                          ┬º┬ºpush(eval("\x01") != 39);
  388.                                                          while(true)
  389.                                                          {
  390.                                                             if(!┬º┬ºpop())
  391.                                                             {
  392.                                                                set("\x01",eval("\x01") + 361);
  393.                                                                stop();
  394.                                                             }
  395.                                                             else
  396.                                                             {
  397.                                                                if(eval("\x01") == 237)
  398.                                                                {
  399.                                                                   set("\x01",eval("\x01") + 522);
  400.                                                                   if(┬º┬ºpop())
  401.                                                                   {
  402.                                                                      set("\x01",eval("\x01") + 186);
  403.                                                                   }
  404.                                                                   continue loop9;
  405.                                                                }
  406.                                                                if(eval("\x01") == 789)
  407.                                                                {
  408.                                                                   set("\x01",eval("\x01") + 100);
  409.                                                                   if(┬º┬ºpop())
  410.                                                                   {
  411.                                                                      set("\x01",eval("\x01") - 423);
  412.                                                                   }
  413.                                                                   continue loop9;
  414.                                                                }
  415.                                                                if(eval("\x01") == 354)
  416.                                                                {
  417.                                                                   break;
  418.                                                                }
  419.                                                                if(eval("\x01") == 771)
  420.                                                                {
  421.                                                                   set("\x01",eval("\x01") + 27);
  422.                                                                   continue loop9;
  423.                                                                }
  424.                                                                if(eval("\x01") == 325)
  425.                                                                {
  426.                                                                   set("\x01",eval("\x01") + 430);
  427.                                                                   continue loop9;
  428.                                                                }
  429.                                                                if(eval("\x01") == 47)
  430.                                                                {
  431.                                                                   set("\x01",eval("\x01") + 123);
  432.                                                                }
  433.                                                                else
  434.                                                                {
  435.                                                                   if(eval("\x01") == 31)
  436.                                                                   {
  437.                                                                      set("\x01",eval("\x01") + 925);
  438.                                                                      set("\t",3);
  439.                                                                      continue loop9;
  440.                                                                   }
  441.                                                                   if(eval("\x01") == 791)
  442.                                                                   {
  443.                                                                      set("\x01",eval("\x01") - 760);
  444.                                                                      if(┬º┬ºpop())
  445.                                                                      {
  446.                                                                         set("\x01",eval("\x01") + 740);
  447.                                                                      }
  448.                                                                      continue loop9;
  449.                                                                   }
  450.                                                                   if(eval("\x01") == 956)
  451.                                                                   {
  452.                                                                      set("\x01",eval("\x01") - 22);
  453.                                                                      if(eval("\t") != 3)
  454.                                                                      {
  455.                                                                         continue loop9;
  456.                                                                      }
  457.                                                                      nextFrame();
  458.                                                                   }
  459.                                                                   else
  460.                                                                   {
  461.                                                                      if(eval("\x01") == 945)
  462.                                                                      {
  463.                                                                         set("\x01",eval("\x01") - 207);
  464.                                                                         continue loop9;
  465.                                                                      }
  466.                                                                      if(eval("\x01") == 747)
  467.                                                                      {
  468.                                                                         set("\x01",eval("\x01") - 393);
  469.                                                                         if(┬º┬ºpop())
  470.                                                                         {
  471.                                                                            set("\x01",eval("\x01") + 391);
  472.                                                                         }
  473.                                                                         continue loop9;
  474.                                                                      }
  475.                                                                      if(eval("\x01") == 759)
  476.                                                                      {
  477.                                                                         set("\x01",eval("\x01") + 186);
  478.                                                                      }
  479.                                                                      else if(eval("\x01") == 889)
  480.                                                                      {
  481.                                                                         set("\x01",eval("\x01") - 423);
  482.                                                                         prevFrame();
  483.                                                                      }
  484.                                                                      else
  485.                                                                      {
  486.                                                                         if(eval("\x01") == 524)
  487.                                                                         {
  488.                                                                            set("\x01",eval("\x01") + 214);
  489.                                                                            continue loop9;
  490.                                                                         }
  491.                                                                         if(eval("\x01") == 170)
  492.                                                                         {
  493.                                                                            set("\x01",eval("\x01") + 357);
  494.                                                                            continue loop9;
  495.                                                                         }
  496.                                                                         if(eval("\x01") == 527)
  497.                                                                         {
  498.                                                                            set("\x01",eval("\x01") + 220);
  499.                                                                            ┬º┬ºpush(true);
  500.                                                                            continue loop9;
  501.                                                                         }
  502.                                                                         if(eval("\x01") == 738)
  503.                                                                         {
  504.                                                                            set("\x01",eval("\x01") - 665);
  505.                                                                            continue loop9;
  506.                                                                         }
  507.                                                                         if(eval("\x01") == 690)
  508.                                                                         {
  509.                                                                            set("\x01",eval("\x01") - 690);
  510.                                                                         }
  511.                                                                      }
  512.                                                                   }
  513.                                                                }
  514.                                                             }
  515.                                                             ┬º┬ºgoto(addr1012);
  516.                                                          }
  517.                                                          set("\x01",eval("\x01") + 391);
  518.                                                          set(┬º┬ºpop(),┬º┬ºpop());
  519.                                                          if(┬º┬ºpop())
  520.                                                          {
  521.                                                             set("\x01",eval("\x01") + 153);
  522.                                                          }
  523.                                                          continue loop0;
  524.                                                       }
  525.                                                       set("\x01",eval("\x01") + 617);
  526.                                                       set("Q{invalid_utf8=215}\x1e\x0e{invalid_utf8=208}",function()
  527.                                                       {
  528.                                                          if(this["\x1a!8"] != null)
  529.                                                          {
  530.                                                             if(this["\x0b{invalid_utf8=177}{invalid_utf8=175}{invalid_utf8=181}{invalid_utf8=191}{invalid_utf8=156};"] == this["\x1a!8"])
  531.                                                             {
  532.                                                                stop();
  533.                                                                this["{invalid_utf8=172}E\'&\r"] = true;
  534.                                                             }
  535.                                                          }
  536.                                                       });
  537.                                                    }
  538.                                                    addr1317:
  539.                                                 }
  540.                                                 else if(eval("\x01") == 323)
  541.                                                 {
  542.                                                    set("\x01",eval("\x01") - 179);
  543.                                                    ┬º┬ºgoto(addr1317);
  544.                                                 }
  545.                                                 else if(eval("\x01") == 12)
  546.                                                 {
  547.                                                    set("\x01",eval("\x01") + 265);
  548.                                                    ┬º┬ºgoto(addr1017);
  549.                                                 }
  550.                                                 else if(eval("\x01") == 383)
  551.                                                 {
  552.                                                    set("\x01",eval("\x01") - 371);
  553.                                                    if(┬º┬ºpop())
  554.                                                    {
  555.                                                       set("\x01",eval("\x01") + 265);
  556.                                                    }
  557.                                                    ┬º┬ºgoto(addr1317);
  558.                                                 }
  559.                                                 else if(eval("\x01") == 207)
  560.                                                 {
  561.                                                    set("\x01",eval("\x01") - 86);
  562.                                                    ┬º┬ºgoto(addr1317);
  563.                                                 }
  564.                                                 else if(eval("\x01") == 153)
  565.                                                 {
  566.                                                    set("\x01",eval("\x01") + 405);
  567.                                                 }
  568.                                                 else if(eval("\x01") == 121)
  569.                                                 {
  570.                                                    set("\x01",eval("\x01") + 823);
  571.                                                    this.num = null;
  572.                                                 }
  573.                                                 else if(eval("\x01") == 144)
  574.                                                 {
  575.                                                    set("\x01",eval("\x01") + 239);
  576.                                                    ┬º┬ºgoto(addr1317);
  577.                                                    ┬º┬ºpush(true);
  578.                                                 }
  579.                                                 else if(eval("\x01") == 995)
  580.                                                 {
  581.                                                    set("\x01",eval("\x01") - 851);
  582.                                                    ┬º┬ºgoto(addr1317);
  583.                                                 }
  584.                                                 else if(eval("\x01") == 558)
  585.                                                 {
  586.                                                    set("\x01",eval("\x01") - 437);
  587.                                                    ┬º┬ºgoto(addr1317);
  588.                                                 }
  589.                                                 else if(eval("\x01") == 944)
  590.                                                 {
  591.                                                    set("\x01",eval("\x01") - 944);
  592.                                                 }
  593.                                              }
  594.                                           }
  595.                                           else
  596.                                           {
  597.                                              if(eval("\x01") == 660)
  598.                                              {
  599.                                                 break;
  600.                                              }
  601.                                              if(eval("\x01") == 662)
  602.                                              {
  603.                                                 set("\x01",eval("\x01") - 635);
  604.                                                 continue;
  605.                                              }
  606.                                              if(eval("\x01") == 990)
  607.                                              {
  608.                                                 set("\x01",eval("\x01") - 52);
  609.                                                 continue;
  610.                                              }
  611.                                              if(eval("\x01") == 146)
  612.                                              {
  613.                                                 set("\x01",eval("\x01") + 514);
  614.                                                 ┬º┬ºpush(true);
  615.                                                 continue;
  616.                                              }
  617.                                              if(eval("\x01") == 296)
  618.                                              {
  619.                                                 set("\x01",eval("\x01") - 269);
  620.                                                 continue;
  621.                                              }
  622.                                              if(eval("\x01") == 109)
  623.                                              {
  624.                                                 set("\x01",eval("\x01") + 455);
  625.                                                 ┬º┬ºpush(true);
  626.                                                 continue;
  627.                                              }
  628.                                              if(eval("\x01") == 277)
  629.                                              {
  630.                                                 set("\x01",eval("\x01") - 27);
  631.                                                 continue;
  632.                                              }
  633.                                              if(eval("\x01") == 256)
  634.                                              {
  635.                                                 set("\x01",eval("\x01") + 511);
  636.                                                 continue;
  637.                                              }
  638.                                              if(eval("\x01") == 595)
  639.                                              {
  640.                                                 set("\x01",eval("\x01") + 71);
  641.                                                 ┬º┬ºpush(┬º┬ºpop()[┬º┬ºpop()]);
  642.                                              }
  643.                                              else
  644.                                              {
  645.                                                 if(eval("\x01") == 468)
  646.                                                 {
  647.                                                    set("\x01",eval("\x01") + 355);
  648.                                                    continue;
  649.                                                 }
  650.                                                 if(eval("\x01") == 257)
  651.                                                 {
  652.                                                    set("\x01",eval("\x01") + 430);
  653.                                                    if(┬º┬ºpop())
  654.                                                    {
  655.                                                       set("\x01",eval("\x01") + 246);
  656.                                                    }
  657.                                                    continue;
  658.                                                 }
  659.                                                 if(eval("\x01") == 83)
  660.                                                 {
  661.                                                    set("\x01",eval("\x01") + 740);
  662.                                                    continue;
  663.                                                 }
  664.                                                 if(eval("\x01") == 938)
  665.                                                 {
  666.                                                    set("\x01",eval("\x01") - 681);
  667.                                                    ┬º┬ºpush(true);
  668.                                                    continue;
  669.                                                 }
  670.                                                 if(eval("\x01") == 45)
  671.                                                 {
  672.                                                    set("\x01",eval("\x01") + 38);
  673.                                                 }
  674.                                                 else
  675.                                                 {
  676.                                                    if(eval("\x01") == 564)
  677.                                                    {
  678.                                                       set("\x01",eval("\x01") - 109);
  679.                                                       if(┬º┬ºpop())
  680.                                                       {
  681.                                                          set("\x01",eval("\x01") - 199);
  682.                                                       }
  683.                                                       continue;
  684.                                                    }
  685.                                                    if(eval("\x01") == 687)
  686.                                                    {
  687.                                                       set("\x01",eval("\x01") + 246);
  688.                                                       ┬º┬ºpush(length(┬º┬ºpop()) + 1);
  689.                                                    }
  690.                                                    else if(eval("\x01") == 455)
  691.                                                    {
  692.                                                       set("\x01",eval("\x01") - 199);
  693.                                                    }
  694.                                                    else
  695.                                                    {
  696.                                                       if(eval("\x01") == 691)
  697.                                                       {
  698.                                                          set("\x01",eval("\x01") - 646);
  699.                                                          if(┬º┬ºpop())
  700.                                                          {
  701.                                                             set("\x01",eval("\x01") + 38);
  702.                                                          }
  703.                                                          continue;
  704.                                                       }
  705.                                                       if(eval("\x01") == 286)
  706.                                                       {
  707.                                                          set("\x01",eval("\x01") + 627);
  708.                                                          if(┬º┬ºpop())
  709.                                                          {
  710.                                                             set("\x01",eval("\x01") - 447);
  711.                                                          }
  712.                                                          continue;
  713.                                                       }
  714.                                                    }
  715.                                                 }
  716.                                              }
  717.                                           }
  718.                                        }
  719.                                     }
  720.                                  }
  721.                               }
  722.                               set("\x01",eval("\x01") - 196);
  723.                               if(!┬º┬ºpop())
  724.                               {
  725.                                  continue;
  726.                               }
  727.                               continue loop3;
  728.                            }
  729.                            set("\x01",eval("\x01") + 181);
  730.                         }
  731.                      }
  732.                      else
  733.                      {
  734.                         if(eval("\x01") == 874)
  735.                         {
  736.                            set("\x01",eval("\x01") - 242);
  737.                            continue;
  738.                         }
  739.                         if(eval("\x01") == 620)
  740.                         {
  741.                            set("\x01",eval("\x01") + 234);
  742.                            continue;
  743.                         }
  744.                         if(eval("\x01") == 645)
  745.                         {
  746.                            set("\x01",eval("\x01") - 605);
  747.                            ┬º┬ºpush(true);
  748.                            continue;
  749.                         }
  750.                         if(eval("\x01") == 64)
  751.                         {
  752.                            set("\x01",eval("\x01") + 766);
  753.                            continue;
  754.                         }
  755.                         if(eval("\x01") == 605)
  756.                         {
  757.                            set("\x01",eval("\x01") + 123);
  758.                            continue loop11;
  759.                         }
  760.                         if(eval("\x01") == 353)
  761.                         {
  762.                            set("\x01",eval("\x01") - 130);
  763.                            if(┬º┬ºpop())
  764.                            {
  765.                               set("\x01",eval("\x01") + 157);
  766.                            }
  767.                            continue;
  768.                         }
  769.                         if(eval("\x01") == 553)
  770.                         {
  771.                            set("\x01",eval("\x01") + 92);
  772.                            continue;
  773.                         }
  774.                         if(eval("\x01") == 288)
  775.                         {
  776.                            set("\x01",eval("\x01") + 566);
  777.                            continue;
  778.                         }
  779.                         if(eval("\x01") == 606)
  780.                         {
  781.                            set("\x01",eval("\x01") - 53);
  782.                            ┬º┬ºpush(┬º┬ºpop() - 1);
  783.                         }
  784.                         else if(eval("\x01") == 112)
  785.                         {
  786.                            set("\x01",eval("\x01") + 176);
  787.                            ┬º┬ºconstant(17)(┬º┬ºconstant(14),┬º┬ºconstant(14) + eval(┬º┬ºconstant(15))[┬º┬ºconstant(16) + eval("`{invalid_utf8=239}{invalid_utf8=191}sX\x04{invalid_utf8=233}")][┬º┬ºconstant(3)],eval("╠ª-{invalid_utf8=130}")[┬º┬ºconstant(13)](),┬º┬ºpop());
  788.                            eval("╠ª-{invalid_utf8=130}")[┬º┬ºconstant(14) + eval(┬º┬ºconstant(15))[┬º┬ºconstant(16) + eval("`{invalid_utf8=239}{invalid_utf8=191}sX\x04{invalid_utf8=233}")][┬º┬ºconstant(3)]][┬º┬ºconstant(18)] = ┬º┬ºconstant(14);
  789.                            eval(┬º┬ºconstant(15))[┬º┬ºconstant(16) + eval("`{invalid_utf8=239}{invalid_utf8=191}sX\x04{invalid_utf8=233}")][┬º┬ºconstant(19)] = 6;
  790.                            eval(┬º┬ºconstant(15))[┬º┬ºconstant(14) + eval(┬º┬ºconstant(15))[┬º┬ºconstant(16) + eval(┬º┬ºconstant(2))][┬º┬ºconstant(3)]][┬º┬ºconstant(3)] = eval(┬º┬ºconstant(15))[┬º┬ºconstant(16) + eval(┬º┬ºconstant(2))][┬º┬ºconstant(3)];
  791.                            eval(┬º┬ºconstant(15))[┬º┬ºconstant(16) + eval(┬º┬ºconstant(2))][┬º┬ºconstant(21)] = getTimer();
  792.                            eval(┬º┬ºconstant(15))[┬º┬ºconstant(16) + eval(┬º┬ºconstant(2))][┬º┬ºconstant(22)] = getTimer();
  793.                         }
  794.                         else
  795.                         {
  796.                            if(eval("\x01") != 43)
  797.                            {
  798.                               if(eval("\x01") == 40)
  799.                               {
  800.                                  set("\x01",eval("\x01") + 548);
  801.                                  if(┬º┬ºpop())
  802.                                  {
  803.                                     set("\x01",eval("\x01") - 524);
  804.                                  }
  805.                               }
  806.                               else if(eval("\x01") == 614)
  807.                               {
  808.                                  set("\x01",eval("\x01") + 114);
  809.                               }
  810.                               else if(eval("\x01") == 722)
  811.                               {
  812.                                  set("\x01",eval("\x01") + 96);
  813.                               }
  814.                               else if(eval("\x01") == 159)
  815.                               {
  816.                                  set("\x01",eval("\x01") + 447);
  817.                                  if(┬º┬ºpop())
  818.                                  {
  819.                                     set("\x01",eval("\x01") - 53);
  820.                                  }
  821.                               }
  822.                               else if(eval("\x01") == 380)
  823.                               {
  824.                                  set("\x01",eval("\x01") + 71);
  825.                               }
  826.                               else
  827.                               {
  828.                                  if(eval("\x01") != 241)
  829.                                  {
  830.                                     break;
  831.                                  }
  832.                                  set("\x01",eval("\x01") + 210);
  833.                               }
  834.                               continue;
  835.                            }
  836.                            set("\x01",eval("\x01") + 819);
  837.                         }
  838.                      }
  839.                   }
  840.                }
  841.                ┬º┬ºpush("\x01");
  842.                while(true)
  843.                {
  844.                   if(eval(┬º┬ºpop()) == 400)
  845.                   {
  846.                      set("\x01",eval("\x01") + 214);
  847.                   }
  848.                   else if(eval("\x01") == 379)
  849.                   {
  850.                      set("\x01",eval("\x01") - 336);
  851.                      if(┬º┬ºpop())
  852.                      {
  853.                         set("\x01",eval("\x01") + 819);
  854.                      }
  855.                      ┬º┬ºgoto(addr34);
  856.                   }
  857.                   else if(eval("\x01") == 880)
  858.                   {
  859.                      set("\x01",eval("\x01") - 480);
  860.                      if(┬º┬ºpop())
  861.                      {
  862.                         set("\x01",eval("\x01") + 214);
  863.                      }
  864.                      ┬º┬ºgoto(addr34);
  865.                   }
  866.                   else if(eval("\x01") == 366)
  867.                   {
  868.                      set("\x01",eval("\x01") - 254);
  869.                      if(┬º┬ºpop())
  870.                      {
  871.                         set("\x01",eval("\x01") + 176);
  872.                      }
  873.                      ┬º┬ºgoto(addr34);
  874.                   }
  875.                   else if(eval("\x01") == 797)
  876.                   {
  877.                      set("\x01",eval("\x01") + 33);
  878.                      ┬º┬ºgoto(addr34);
  879.                   }
  880.                   else if(eval("\x01") == 420)
  881.                   {
  882.                      set("\x01",eval("\x01") + 302);
  883.                   }
  884.                   else if(eval("\x01") == 451)
  885.                   {
  886.                      set("\x01",eval("\x01") + 429);
  887.                      ┬º┬ºgoto(addr34);
  888.                      ┬º┬ºpush(true);
  889.                   }
  890.                   else if(eval("\x01") == 830)
  891.                   {
  892.                      set("\x01",eval("\x01") - 736);
  893.                      ┬º┬ºgoto(addr34);
  894.                      ┬º┬ºpush(true);
  895.                   }
  896.                   else if(eval("\x01") == 439)
  897.                   {
  898.                      set("\x01",eval("\x01") + 206);
  899.                      ┬º┬ºgoto(addr34);
  900.                   }
  901.                   else if(eval("\x01") == 988)
  902.                   {
  903.                      set("\x01",eval("\x01") - 170);
  904.                      ┬º┬ºgoto(addr34);
  905.                   }
  906.                   else if(eval("\x01") == 588)
  907.                   {
  908.                      set("\x01",eval("\x01") - 524);
  909.                      nextFrame();
  910.                   }
  911.                   else if(eval("\x01") == 3)
  912.                   {
  913.                      set("\x01",eval("\x01") + 629);
  914.                      ┬º┬ºgoto(addr34);
  915.                   }
  916.                   else if(eval("\x01") == 632)
  917.                   {
  918.                      set("\x01",eval("\x01") - 462);
  919.                      ┬º┬ºgoto(addr34);
  920.                      ┬º┬ºpush(true);
  921.                   }
  922.                   else if(eval("\x01") == 818)
  923.                   {
  924.                      set("\x01",eval("\x01") - 439);
  925.                      ┬º┬ºgoto(addr34);
  926.                      ┬º┬ºpush(true);
  927.                   }
  928.                   else if(eval("\x01") == 170)
  929.                   {
  930.                      set("\x01",eval("\x01") + 250);
  931.                      if(┬º┬ºpop())
  932.                      {
  933.                         set("\x01",eval("\x01") + 302);
  934.                      }
  935.                      ┬º┬ºgoto(addr34);
  936.                   }
  937.                   else if(eval("\x01") == 862)
  938.                   {
  939.                      set("\x01",eval("\x01") - 715);
  940.                      ┬º┬ºgoto(addr34);
  941.                   }
  942.                   else if(eval("\x01") == 770)
  943.                   {
  944.                      set("\x01",eval("\x01") - 623);
  945.                      ┬º┬ºgoto(addr34);
  946.                   }
  947.                   else if(eval("\x01") == 147)
  948.                   {
  949.                      set("\x01",eval("\x01") + 219);
  950.                      ┬º┬ºgoto(addr34);
  951.                      ┬º┬ºpush(true);
  952.                   }
  953.                   else if(eval("\x01") == 734)
  954.                   {
  955.                      set("\x01",eval("\x01") - 734);
  956.                   }
  957.                   ┬º┬ºgoto(addr377);
  958.                }
  959.             }
  960.          }
  961.          else
  962.          {
  963.             if(eval("\x01") == 161)
  964.             {
  965.                set("\x01",eval("\x01") - 30);
  966.                ┬º┬ºpush(true);
  967.                continue;
  968.             }
  969.             if(eval("\x01") == 729)
  970.             {
  971.                ┬º┬ºpush("\x01");
  972.                ┬º┬ºpush(eval("\x01") - 604);
  973.             }
  974.             else
  975.             {
  976.                if(eval("\x01") == 21)
  977.                {
  978.                   set("\x01",eval("\x01") + 140);
  979.                   continue;
  980.                }
  981.                if(eval("\x01") == 106)
  982.                {
  983.                   set("\x01",eval("\x01") - 24);
  984.                   if(┬º┬ºpop())
  985.                   {
  986.                      set("\x01",eval("\x01") + 448);
  987.                   }
  988.                   continue;
  989.                }
  990.                if(eval("\x01") == 991)
  991.                {
  992.                   set("\x01",eval("\x01") - 387);
  993.                   ┬º┬ºgoto(addr2935);
  994.                }
  995.                if(eval("\x01") == 233)
  996.                {
  997.                   set("\x01",eval("\x01") + 564);
  998.                   ┬º┬ºpush(true);
  999.                   continue;
  1000.                }
  1001.                if(eval("\x01") == 273)
  1002.                {
  1003.                   set("\x01",eval("\x01") - 167);
  1004.                   ┬º┬ºpush(true);
  1005.                   continue;
  1006.                }
  1007.                if(eval("\x01") == 799)
  1008.                {
  1009.                   set("\x01",eval("\x01") + 192);
  1010.                   if(┬º┬ºpop())
  1011.                   {
  1012.                      set("\x01",eval("\x01") - 387);
  1013.                   }
  1014.                   continue;
  1015.                }
  1016.                if(eval("\x01") == 594)
  1017.                {
  1018.                   set("\x01",eval("\x01") + 39);
  1019.                   continue;
  1020.                }
  1021.                if(eval("\x01") == 131)
  1022.                {
  1023.                   set("\x01",eval("\x01") - 2);
  1024.                   if(┬º┬ºpop())
  1025.                   {
  1026.                      set("\x01",eval("\x01") + 583);
  1027.                   }
  1028.                   continue;
  1029.                }
  1030.                if(eval("\x01") == 604)
  1031.                {
  1032.                   set("\x01",eval("\x01") + 29);
  1033.                   continue;
  1034.                }
  1035.                if(eval("\x01") == 150)
  1036.                {
  1037.                   set("\x01",eval("\x01") - 129);
  1038.                   ┬º┬ºgoto(addr2935);
  1039.                }
  1040.                else
  1041.                {
  1042.                   if(eval("\x01") == 693)
  1043.                   {
  1044.                      set("\x01",eval("\x01") + 248);
  1045.                      if(┬º┬ºpop())
  1046.                      {
  1047.                         set("\x01",eval("\x01") - 585);
  1048.                      }
  1049.                      continue;
  1050.                   }
  1051.                   if(eval("\x01") == 38)
  1052.                   {
  1053.                      set("\x01",eval("\x01") + 195);
  1054.                      continue;
  1055.                   }
  1056.                   if(eval("\x01") == 278)
  1057.                   {
  1058.                      set("\x01",eval("\x01") - 5);
  1059.                      continue;
  1060.                   }
  1061.                   if(eval("\x01") == 688)
  1062.                   {
  1063.                      set("\x01",eval("\x01") - 86);
  1064.                      continue;
  1065.                   }
  1066.                   if(eval("\x01") == 82)
  1067.                   {
  1068.                      set("\x01",eval("\x01") + 448);
  1069.                      ┬º┬ºgoto(addr378);
  1070.                   }
  1071.                   else
  1072.                   {
  1073.                      if(eval("\x01") == 530)
  1074.                      {
  1075.                         set("\x01",eval("\x01") - 268);
  1076.                         continue;
  1077.                      }
  1078.                      if(eval("\x01") == 856)
  1079.                      {
  1080.                         set("\x01",eval("\x01") - 57);
  1081.                         ┬º┬ºpush(true);
  1082.                         continue;
  1083.                      }
  1084.                      if(eval("\x01") == 472)
  1085.                      {
  1086.                         set("\x01",eval("\x01") - 210);
  1087.                         continue;
  1088.                      }
  1089.                      if(eval("\x01") == 129)
  1090.                      {
  1091.                         set("\x01",eval("\x01") + 583);
  1092.                      }
  1093.                      else
  1094.                      {
  1095.                         if(eval("\x01") == 225)
  1096.                         {
  1097.                            set("\x01",eval("\x01") - 64);
  1098.                            continue;
  1099.                         }
  1100.                         if(eval("\x01") == 849)
  1101.                         {
  1102.                            set("\x01",eval("\x01") - 732);
  1103.                            if(┬º┬ºpop())
  1104.                            {
  1105.                               set("\x01",eval("\x01") + 40);
  1106.                            }
  1107.                            continue;
  1108.                         }
  1109.                         if(eval("\x01") == 262)
  1110.                         {
  1111.                            set("\x01",eval("\x01") + 431);
  1112.                            ┬º┬ºpush(true);
  1113.                            continue;
  1114.                         }
  1115.                         if(eval("\x01") == 797)
  1116.                         {
  1117.                            set("\x01",eval("\x01") - 182);
  1118.                            if(┬º┬ºpop())
  1119.                            {
  1120.                               set("\x01",eval("\x01") - 404);
  1121.                            }
  1122.                            continue;
  1123.                         }
  1124.                         if(eval("\x01") == 211)
  1125.                         {
  1126.                            set("\x01",eval("\x01") - 16);
  1127.                            continue;
  1128.                         }
  1129.                         if(eval("\x01") == 783)
  1130.                         {
  1131.                            set("\x01",eval("\x01") - 109);
  1132.                            if(┬º┬ºpop())
  1133.                            {
  1134.                               set("\x01",eval("\x01") + 14);
  1135.                            }
  1136.                            continue;
  1137.                         }
  1138.                         if(eval("\x01") == 702)
  1139.                         {
  1140.                            set("\x01",eval("\x01") - 552);
  1141.                            if(┬º┬ºpop())
  1142.                            {
  1143.                               set("\x01",eval("\x01") - 129);
  1144.                            }
  1145.                            continue;
  1146.                         }
  1147.                         if(eval("\x01") == 195)
  1148.                         {
  1149.                            set("\x01",eval("\x01") + 588);
  1150.                            ┬º┬ºpush(true);
  1151.                            continue;
  1152.                         }
  1153.                         if(eval("\x01") == 941)
  1154.                         {
  1155.                            set("\x01",eval("\x01") - 585);
  1156.                         }
  1157.                         else
  1158.                         {
  1159.                            if(eval("\x01") == 599)
  1160.                            {
  1161.                               set("\x01",eval("\x01") - 404);
  1162.                               continue;
  1163.                            }
  1164.                            if(eval("\x01") == 356)
  1165.                            {
  1166.                               set("\x01",eval("\x01") + 500);
  1167.                               continue;
  1168.                            }
  1169.                            if(eval("\x01") == 418)
  1170.                            {
  1171.                               set("\x01",eval("\x01") + 284);
  1172.                               ┬º┬ºpush(true);
  1173.                               continue;
  1174.                            }
  1175.                            if(eval("\x01") == 602)
  1176.                            {
  1177.                               set("\x01",eval("\x01") - 264);
  1178.                               this.num = null;
  1179.                            }
  1180.                            else if(eval("\x01") == 338)
  1181.                            {
  1182.                               set("\x01",eval("\x01") - 338);
  1183.                            }
  1184.                            else
  1185.                            {
  1186.                               if(eval("\x01") == 62)
  1187.                               {
  1188.                                  set("\x01",eval("\x01") + 794);
  1189.                                  continue;
  1190.                               }
  1191.                               if(eval("\x01") == 117)
  1192.                               {
  1193.                                  set("\x01",eval("\x01") + 40);
  1194.                               }
  1195.                               else
  1196.                               {
  1197.                                  if(eval("\x01") == 944)
  1198.                                  {
  1199.                                     set("\x01",eval("\x01") - 526);
  1200.                                     continue;
  1201.                                  }
  1202.                                  if(eval("\x01") == 157)
  1203.                                  {
  1204.                                     set("\x01",eval("\x01") + 261);
  1205.                                     continue;
  1206.                                  }
  1207.                               }
  1208.                            }
  1209.                         }
  1210.                      }
  1211.                      ┬º┬ºgoto(addr2935);
  1212.                   }
  1213.                }
  1214.                addr2935:
  1215.                ┬º┬ºpop() add ┬º┬ºpop();
  1216.                ┬º┬ºgoto(addr2935);
  1217.             }
  1218.             ┬º┬ºgoto(addr2365);
  1219.          }
  1220.       }
  1221.    }
  1222.    ┬º┬ºgoto(addr2935);
  1223. }
  1224.